package start.demo01;

import java.util.Stack;

/*
* 使用栈（operandStack,operatorStack）分别存数和操作符
* 从左到右扫描表达式，
* 1.操作数压入operandStack
* 2.如果是+或-运算符，处理operatorStack栈顶所有运算符，并将提取到的运算符压入到operatorStack
* 3.如果是*或/，处理栈顶所有的*和/运算符，并将提取到的运算符压入到operatorStack
* 4.如果提取到的是(,将提取到的运算符压入到operatorStack
* 5.如果提取的是），重复处理来自operatorStack栈顶的运算符，直到遇到（
*~~~~~~~~~~~~~~~~~
* （1）若取出的字符是操作数，则分析出完整的运算数，该操作数直接送入S2栈
（2）若取出的字符是运算符，则将该运算符与S1栈栈顶元素比较，如果该运算符优先级(不包括括号运算符)大于S1栈栈顶运算符优先级，则将该运算符进S1栈，否则，将S1栈的栈顶运算符弹出，送入S2栈中，直至S1栈栈顶运算符低于（不包括等于）该运算符优先级，最后将该运算符送入S1栈。
（3）若取出的字符是“（”，则直接送入S1栈顶。
（4）若取出的字符是“）”，则将距离S1栈栈顶最近的“（”之间的运算符，逐个出栈，依次送入S2栈，此时抛弃“（”。
（5）重复上面的1~4步，直至处理完所有的输入字符
（6）若取出的字符是“#”，则将S1栈内所有运算符（不包括“#”），逐个出栈，依次送入S2栈。
完成以上步骤，S2栈便为逆波兰式输出结果。不过S2应做一下逆序处理。便可以按照逆波兰式的计算方法计算了！
* */
public class EvaluateExpression {
    public static void main(String[] args){
        EvaluateExpression ee=new EvaluateExpression();
        //ee.calculator();
        String s=ee.complement("(-232)-21-");
        System.out.println(s);
    }
    public void calculator(){
        Stack<Integer> operandStack=new Stack<Integer>();
        Stack<Character> operatorStack=new Stack<Character>();//运算符
        operatorStack.push('#');
        String s="(1-2*3)+5*6";//0
        boolean flag=false;
        for(int i=0;i<s.length();i++){
            Character tmp;
            tmp=s.charAt(i);
            System.out.println("检查："+tmp);
            //可能连续进入运算符，但不可能连续进入操作数
            if((tmp>=48&&tmp<=57)||tmp=='.'){//数值型
                if(flag){//数连接
                    operandStack.push(operandStack.pop()*10+Integer.parseInt(tmp+""));
                }else{
                    System.out.println("操作数进栈:"+tmp);
                    operandStack.push(Integer.parseInt(tmp+""));
                }
            }else{//运算符
                if(rating(tmp)>=rating(operatorStack.peek())){//高运算级进栈
                    System.out.println("运算符进栈:"+tmp);
                    operatorStack.push(tmp);
                }else{//出栈操作
                    System.out.println("运算符出栈:"+operatorStack.peek());
                    if(operatorStack.peek()=='('){//此处必定和)匹配
                        operatorStack.pop();
                        //System.out.println("栈顶:"+(operandStack.empty()?0:operandStack.peek())+" "+operatorStack.peek());
                        continue;
                    }else {
                        int t = operation(operandStack.pop(), operandStack.pop(), operatorStack.pop());
                        operandStack.push(t);
                    }
                    i--;//继续对此运算符比较
                }
            }
            System.out.println("栈顶:"+(operandStack.empty()?0:operandStack.peek())+" "+operatorStack.peek());
        }
        while(operatorStack.peek()!='#'){
            int t=operation(operandStack.pop(),operandStack.pop(),operatorStack.pop());
            operandStack.push(t);
        }
        System.out.println(operandStack.pop());
    }
    public int operation(int b,int a,Character ch){//运算
        switch(ch){
            case '+':
                return a+b;
            case '-':
                return a-b;
            case '*':
                return a*b;
            case '/':
                return a/b;
            default:
                return 0;
        }
    }
    public int rating(Character b){//等级
        int re=0;
        //(1-2*3)+5*6结尾依次出栈
        switch(b){
            case '#':
                re=0;break;
            case '(':
                re=2;break;
            case ')'://不会用到
                re=1;break;
            case '+':
            case '-':
                re=3;break;
            case '*':
            case '/':
                re=5;break;
        }
        return re;
    }
    public String complement(String s){
        String[] debris=s.split("-");
        for(int i=0;i<debris.length-1;i++){
            int len=0;
            len=debris[i].length();
            System.out.println(debris[i]+"  "+len);
            if(len!=0) {
                if((debris[i].charAt(len - 1) >= 48 && debris[i].charAt(len - 1) <= 57)||debris[i].charAt(len - 1)==41){//是操作数或）
                    debris[i]=debris[i]+"-";
                }else{
                    debris[i]=debris[i]+"0-";
                }
            }else
                debris[i]="0-";

        }
        String end="";
        for(String t:debris)
            end+=t;
        return end;
    }
}

